namespace A::B::C {
   // ...
}

// Rather than:
namespace A {
    namespace B {
        namespace C {
            // ...
        }
    }
}

#include <map>
#include <string>
#include <iostream>

struct Vector3
{
    float X;
    float Y;
    float Z;
};
using MappingPair = std::pair<int, std::string>;

int main()
{
    const auto [x, y, z] = Vector3{1.0f, 1.0f, 1.0f};
    std::map<int, std::string> mapping
    {
        {1, "one"},
        {2, "two"}
    };
    const auto [it, isInserted] = mapping.insert(MappingPair{3, "three"});
    std::cout << it->first << " " << it->second << "\n\n";

    for (const auto& [key, value] : mapping)
    {
        std::cout << key << " " << value << std::endl;
    }
}

{
  std::lock_guard<std::mutex> lk(mx);
  if (v.empty()) v.push_back(val);
}
// vs.
if (std::lock_guard<std::mutex> lk(mx); v.empty()) {
  v.push_back(val);
}

template <typename T>
constexpr bool isIntegral() {
  if constexpr (std::is_integral<T>::value) {
    return true;
  } else {
    return false;
  }
}
static_assert(isIntegral<int>() == true);
static_assert(isIntegral<char>() == true);
static_assert(isIntegral<double>() == false);
struct S {};
static_assert(isIntegral<S>() == false);

auto pair = std::pair{1.0, "foo"}; // Deduces to std::pair<double, std::string>;

switch (n) {
  case 1: 
    // ...
    [[fallthrough]];
  case 2:
    // ...
    break;
  case 3:
    // ...
    [[fallthrough]];
  default:
    // ...
}

[[nodiscard]] bool do_something() {
  return is_success; // true for success, false for failure
}

do_something(); // warning: ignoring return value of 'bool do_something()',
                // declared with attribute 'nodiscard'

// Only issues a warning when `error_info` is returned by value.
struct [[nodiscard]] error_info {
  // ...
};

error_info do_something() {
  error_info ei;
  // ...
  return ei;
}

do_something(); // warning: ignoring returned value of type 'error_info',
                // declared with attribute 'nodiscard'

void my_callback(std::string msg, [[maybe_unused]] bool error) {
  // Don't care if `msg` is an error message, just log it.
  log(msg);
}

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

using SettingVarT = std::variant<int, std::string>;


class SettingVisitorWithClosure
{
public:
    SettingVisitorWithClosure(const std::string& str)
        : _str(str)
    {
    } 

    void operator()(int args)
    {
        std::cout << _str << " integer " << args << std::endl;
    }

    void operator()(std::string args)
    {
        std::cout << _str << " string " << args << std::endl;
    }

private:
    std::string _str = "Hello";
};

int main ()
{ 
    SettingVarT setting = 0;

    ////////////////////////////////////////////////////////////////////////////////
    // Lambda std::variant visitor without closure
    std::visit([](auto&& args)
    {
        using T = std::decay_t<decltype(args)>;

        if constexpr (std::is_same_v<T, int>)
        {
            std::cout << "integer " << args << std::endl;
        }
        if constexpr (std::is_same_v<T, std::string>)
        {
            std::cout << "string" << args << std::endl;
        }
    }, setting);

    ////////////////////////////////////////////////////////////////////////////////
    // Variant visitor with closure
    SettingVisitorWithClosure closure("Hello");
    std::visit(std::move(closure), setting);
}